home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1993 July / InfoMagic USENET CD-ROM July 1993.ISO / sources / unix / volume9 / xterm / part07 < prev    next >
Encoding:
Internet Message Format  |  1987-04-21  |  60.4 KB
  1. Subject:  v09i060:  Terminal emulator for X window system, Part07/07
  2. Newsgroups: mod.sources, comp.sources.unix
  3. Approved: rs@mirror.TMC.COM
  4.  
  5. Submitted by: edmoy@opal.Berkeley.EDU
  6. Mod.sources: Volume 9, Issue 60
  7. Archive-name: xterm6.6b/Part07
  8.  
  9. [  Following the schedule, I'll be posting articles to both the old and
  10.    the new name for a while; sorry, notes sites.  --r$  ]
  11.   
  12.  
  13. #! /bin/sh
  14. # This is a shell archive, meaning:
  15. # 1. Remove everything above the #! /bin/sh line.
  16. # 2. Save the resulting text in a file.
  17. # 3. Execute the file with /bin/sh (not csh) to create the files:
  18. #    Makefile scrollbar.c tabs.c termcap terminfo util.c Xlib/Makefile
  19. #    Xlib/README Xlib/XKeyBind.c
  20. if test -f Makefile
  21. then
  22.     echo shar: will not overwrite existing file "'Makefile'"
  23. else
  24. echo 'x - Makefile'
  25. cat << \RAZZLE!DAZZLE > Makefile
  26. #
  27. #     $Source: /u1/X/xterm/RCS/Makefile,v $
  28. #    $Header: Makefile,v 10.2 86/12/01 17:52:22 swick Rel $
  29. #
  30.  
  31. #
  32. #    Makefile for X window system terminal emulator.
  33. #    @(#)Makefile       X10/6.6B 12/26/86
  34. #
  35.  
  36. DESTDIR=
  37. # We put xterm in /etc so you can run on partial boot.  A link is put
  38. # in CONFDIR so normal search paths will find xterm.
  39. # 
  40. # For the 4.3 distribution, the executable is put in /usr/local instead.
  41. #
  42. CONFDIR= /usr/local
  43. INCLUDES= -I../include
  44. LIBS= ../Xlib/libX.a -ltermcap
  45. #
  46. # The option KEYBD may be included if the keyboard mods have been done to
  47. # XKeyBind.c in libX.a.
  48. cflags = -O -DMODEMENU ${INCLUDES} -DUTMP -DKEYBD
  49. #
  50. # NOWINDOWMENU    disables the window manager menu (right button)
  51. # DROPMENUS    causes the menus to drop from the cursor rather than be
  52. #        centered vertically.
  53. #cflags = -O -DMODEMENU ${INCLUDES} -DUTMP -DNOWINDOWMENU -DDROPMENUS
  54. CFLAGS = -R ${cflags}
  55. SOURCE = Makefile data.h error.h menu.h ptyx.h scrollbar.h VTparse.h \
  56.         Tekparse.h button.c charproc.c cursor.c data.c input.c \
  57.         main.c menu.c misc.c screen.c scrollbar.c tabs.c \
  58.         Tekparsetable.c Tekproc.c util.c VTparsetable.c
  59.  
  60. .SUFFIXES: .o .h .c
  61.  
  62. OBJS =    main.o input.o charproc.o cursor.o util.o tabs.o \
  63.     screen.o scrollbar.o button.o Tekproc.o misc.o \
  64.     VTparsetable.o Tekparsetable.o data.o menu.o
  65.  
  66. all: xterm resize
  67.  
  68. xterm: $(OBJS) ../Xlib/libX.a
  69.     $(CC) $(CFLAGS) -o xterm $(OBJS) $(LIBS)
  70.  
  71. button.o: data.h error.h menu.h ptyx.h scrollbar.h
  72.  
  73. charproc.o: VTparse.h error.h data.h menu.h ptyx.h scrollbar.h
  74.  
  75. cursor.o: ptyx.h
  76.  
  77. data.o: data.c ptyx.h scrollbar.h
  78.     $(CC) $(cflags) -c data.c
  79.  
  80. input.o: ptyx.h
  81.  
  82. main.o: data.h error.h main.h ptyx.h scrollbar.h
  83.  
  84. menu.o: menu.h
  85.  
  86. misc.o: error.h ptyx.h scrollbar.h gray.ic hilite.ic icon.ic wait.ic waitmask.ic
  87.  
  88. screen.o: error.h ptyx.h scrollbar.h
  89.  
  90. scrollbar.o: error.h ptyx.h scrollbar.h button.ic dark.ic light.ic upline.ic \
  91.     downline.ic uppage.ic downpage.ic top.ic bottom.ic saveoff.ic saveon.ic
  92.  
  93. tabs.o: ptyx.h
  94.  
  95. Tekparsetable.o: Tekparse.h
  96.  
  97. Tekproc.o: Tekparse.h error.h data.h menu.h ptyx.h scrollbar.h
  98.  
  99. VTparsetable.o: VTparse.h
  100.  
  101. util.o: ptyx.h scrollbar.h
  102.  
  103. resize: resize.o
  104.     $(CC) $(cflags) -o resize resize.o -lc -ltermcap
  105.  
  106. resize.o: resize.c
  107.     $(CC) $(cflags) -c resize.c
  108.  
  109. install: all
  110. #    install -m 4755 xterm ${DESTDIR}/etc
  111.     install -m 4755 xterm ${DESTDIR}${CONFDIR}
  112. #    rm -f ${DESTDIR}${CONFDIR}/xterm
  113. #    ln -s /etc/xterm ${DESTDIR}${CONFDIR}/xterm
  114.     install resize ${DESTDIR}${CONFDIR}
  115.  
  116. clean:
  117.     rm -f xterm resize *.o a.out core errs gmon.out *.bak *~
  118.  
  119. print:
  120.     lpr -Pln ${SOURCE}
  121. RAZZLE!DAZZLE
  122. fi    # End Makefile
  123. if test -f scrollbar.c
  124. then
  125.     echo shar: will not overwrite existing file "'scrollbar.c'"
  126. else
  127. echo 'x - scrollbar.c'
  128. cat << \RAZZLE!DAZZLE > scrollbar.c
  129. /*
  130.  *    $Source: /u1/X/xterm/RCS/scrollbar.c,v $
  131.  *    $Header: scrollbar.c,v 10.100 86/12/01 14:45:27 jg Rel $
  132.  */
  133.  
  134. #include <stdio.h>
  135. #include <sys/time.h>
  136. #include <X/Xlib.h>
  137. #include <setjmp.h>
  138. #include "scrollbar.h"
  139. #include "ptyx.h"
  140. #include "data.h"
  141. #include "error.h"
  142. #ifdef MODEMENU
  143. #include "menu.h"
  144. #endif MODEMENU
  145.  
  146. #include "button.ic"
  147. #include "dark.ic"
  148. #include "light.ic"
  149. #include "upline.ic"
  150. #include "downline.ic"
  151. #include "uppage.ic"
  152. #include "downpage.ic"
  153. #include "top.ic"
  154. #include "bottom.ic"
  155. #include "saveoff.ic"
  156. #include "saveon.ic"
  157. #ifndef lint
  158. static char sccs_id[] = "@(#)scrollbar.c\tX10/6.6B\t12/26/86";
  159. #endif    lint
  160.  
  161. static struct timeval stepspeed;
  162.  
  163. ScrollBar *
  164. CreateScrollBar(w, x, y, height, fg, bg, bordertile, val, valregion,
  165.  topval, botval, arrow)
  166.     Window w;
  167.     int x, y, height, fg, bg, val, valregion, topval, botval;
  168.     Pixmap bordertile;
  169.     Cursor arrow;
  170. {
  171.     register ScrollBar *sb;
  172.     register int i;
  173.     Pixmap btile, bgnd;
  174.     extern char *calloc();
  175.     static Window Make_tiled_window();
  176.     extern Pixmap Make_tile();
  177.  
  178.     if(!w || height < MINSCROLLBARHEIGHT ||
  179.      (sb = (ScrollBar *)calloc(1, sizeof(ScrollBar))) == NULL)
  180.         return(NULL);
  181.     btile = bordertile;
  182.     if(bg == BlackPixel && fg == WhitePixel) {
  183.         bg = WhitePixel;
  184.         fg = BlackPixel;
  185.         if(btile == WhitePixmap)
  186.             btile = BlackPixmap;
  187.     }
  188.     sb->fg = fg;
  189.     sb->bg = bg;
  190.     sb->cursor = arrow;
  191.     if((sb->bar = Make_tiled_window(light_width, light_height, light_bits,
  192.      fg, bg, &bgnd, w, x, y, (SCROLLBARWIDTH - 1), height, 1, bordertile))
  193.      == NULL)
  194.         goto failed_bar;
  195.     if((sb->button = XCreateWindow(sb->bar, -1, -1, (SCROLLBARWIDTH - 1),
  196.      BUTTONHEIGHT - 1, 1, btile, bgnd)) == NULL)
  197.         goto failed_button;
  198.     if((sb->save = XCreateWindow(sb->bar, -1, BUTTONHEIGHT - 1,
  199.      (SCROLLBARWIDTH - 1), BUTTONHEIGHT - 1, 1, btile, bgnd)) == NULL)
  200.         goto failed_save;
  201.     if((sb->region = Make_tiled_window(dark_width, dark_height, dark_bits,
  202.      fg, bg, &bgnd, sb->bar, 0, 0, (SCROLLBARWIDTH - 1), 10, 0,
  203.      (Pixmap)NULL)) == NULL) {
  204.         XDestroyWindow(sb->save);
  205. failed_save:
  206.         XDestroyWindow(sb->button);
  207. failed_button:
  208.         XDestroyWindow(sb->bar);
  209. failed_bar:
  210.         free((char *)sb);
  211.         return(NULL);
  212.     }
  213.     sb->savebits[SAVE_OFF] = saveoff_bits;
  214.     sb->savebits[SAVE_ON] = saveon_bits;
  215.     sb->buttonbits[BUTTON_UPLINE / 2] = upline_bits;
  216.     sb->buttonbits[BUTTON_DOWNLINE / 2] = downline_bits;
  217.     sb->buttonbits[BUTTON_UPPAGE / 2] = uppage_bits;
  218.     sb->buttonbits[BUTTON_DOWNPAGE / 2] = downpage_bits;
  219.     sb->buttonbits[BUTTON_TOP / 2] = top_bits;
  220.     sb->buttonbits[BUTTON_BOTTOM / 2] = bottom_bits;
  221.     sb->buttonbits[BUTTON_NORMAL / 2] = button_bits;
  222.     XDefineCursor(sb->bar, sb->cursor);
  223.     XSelectInput(sb->bar, ButtonPressed | ButtonReleased | ExposeWindow |
  224.      EnterWindow | LeaveWindow | UnmapWindow);
  225.     XSelectInput(sb->button, EnterWindow | LeaveWindow);
  226.     XMapWindow(sb->button);    /* will really map when bar is mapped */
  227.     XMapWindow(sb->save);    /* will really map when bar is mapped */
  228.     sb->buttonstate = sb->buttonset = BUTTON_NORMAL;
  229.     sb->savestate = sb->saveset = SAVE_ON;
  230.     sb->set.value = val;
  231.     sb->set.regionheight = valregion;
  232.     sb->set.topvalue = topval;
  233.     sb->set.bottomvalue = botval;
  234.     sb->set.height = height - BARSTART;
  235.     return(sb);
  236. }
  237.  
  238. ShowScrollBar(sb)
  239.     register ScrollBar *sb;
  240. {
  241.     if(sb->visible)
  242.         return;
  243.     sb->visible = 1;
  244.     if(sb->regionvisible) {
  245.         XUnmapWindow(sb->region);
  246.         sb->regionvisible = 0;
  247.     }
  248.     XMapWindow(sb->bar);
  249.     DrawScrollRegion(sb);
  250.     sb->action = SHOW;
  251. }
  252.  
  253. HideScrollBar(sb)
  254.     register ScrollBar *sb;
  255. {
  256.     if(!sb->visible)
  257.         return;
  258.     sb->visible = 0;
  259.     XUnmapWindow(sb->bar);
  260. }
  261.  
  262. DrawScrollRegion(sb)
  263.     register ScrollBar *sb;
  264. {
  265.     register int region, temp;
  266.  
  267.     if(sb->set.regionheight <= 0)
  268.         sb->set.regionheight = 0;
  269.     if((region = sb->set.topvalue - sb->set.bottomvalue) >= 0) {
  270.         if(sb->set.value > sb->set.topvalue)
  271.             sb->set.value = sb->set.topvalue;
  272.         else if(sb->set.value < sb->set.bottomvalue)
  273.             sb->set.value = sb->set.bottomvalue;
  274.     } else {
  275.         region = -region;
  276.         if(sb->set.value < sb->set.topvalue)
  277.             sb->set.value = sb->set.topvalue;
  278.         else if(sb->set.value > sb->set.bottomvalue)
  279.             sb->set.value = sb->set.bottomvalue;
  280.     }
  281.     if(sb->set.value == sb->set.topvalue) {
  282.         sb->set.pixelheight = (region == 0) ? sb->set.height :
  283.          (sb->set.height - 1) * sb->set.regionheight /
  284.          (sb->set.regionheight + region);
  285.         sb->set.y = BARSTART;
  286.     } else if(sb->set.value == sb->set.bottomvalue) {
  287.         sb->set.pixelheight = (sb->set.height - 1) *
  288.          sb->set.regionheight / (sb->set.regionheight + region);
  289.         sb->set.y = BARSTART + sb->set.height - sb->set.pixelheight;
  290.     } else {
  291.         if(sb->set.topvalue >= sb->set.bottomvalue) {
  292.             temp = sb->set.topvalue - 1;
  293.             region = temp - (sb->set.bottomvalue + 1);
  294.             sb->set.y = temp - sb->set.value;
  295.         } else {
  296.             temp = sb->set.topvalue + 1;
  297.             region = (sb->set.bottomvalue - 1) - temp;
  298.             sb->set.y = sb->set.value - temp;
  299.         }
  300.         sb->set.y = (BARSTART + 1) + sb->set.y * (sb->set.height - 2) /
  301.          (temp = sb->set.regionheight + region);
  302.         sb->set.pixelheight = (sb->set.height - 2) *
  303.          sb->set.regionheight / temp;
  304.     }
  305.     if(sb->set.pixelheight <= 0)
  306.         sb->set.pixelheight = 1;
  307.     if(sb->set.regionheight == 0) {
  308.         sb->state = sb->set;
  309.         if(sb->regionvisible) {
  310.             XUnmapWindow(sb->region);
  311.             sb->regionvisible = 0;
  312.         }
  313.         return;
  314.     }
  315.     if(!sb->visible || sb->regionvisible
  316.      && sb->state.y == sb->set.y
  317.      && sb->state.pixelheight == sb->set.pixelheight) {
  318.         sb->state = sb->set;
  319.         return;
  320.     }
  321.     sb->state = sb->set;
  322.     XConfigureWindow(sb->region, 0, sb->state.y, (SCROLLBARWIDTH - 1),
  323.      sb->state.pixelheight);
  324.     if(!sb->regionvisible) {
  325.         XMapWindow(sb->region);
  326.         sb->regionvisible = 1;
  327.     }
  328. }
  329.  
  330. DrawButton(sb)
  331.     register ScrollBar *sb;
  332. {
  333.     register int fg, bg;
  334.  
  335.     if(sb->visible && sb->buttonstate != sb->buttonset) {
  336.         if((sb->buttonstate = sb->buttonset) & HILITED) {
  337.             fg = sb->bg;
  338.             bg = sb->fg;
  339.         } else {
  340.             fg = sb->fg;
  341.             bg = sb->bg;
  342.         }
  343.         XBitmapBitsPut(sb->button, 0, 0, SCROLLBARWIDTH - 1,
  344.          BUTTONHEIGHT - 1, sb->buttonbits[sb->buttonstate / 2],
  345.          fg, bg, (Bitmap)0, GXcopy, AllPlanes);
  346.     }
  347. }
  348.  
  349. DrawSave(sb)
  350.     register ScrollBar *sb;
  351. {
  352.     if(sb->visible && sb->savestate != sb->saveset)
  353.         XBitmapBitsPut(sb->save, 0, 0, SCROLLBARWIDTH - 1,
  354.          BUTTONHEIGHT - 1, sb->savebits[sb->savestate = sb->saveset],
  355.          sb->fg, sb->bg, (Bitmap)0, GXcopy, AllPlanes);
  356. }
  357.  
  358. ResizeScrollBar(sb, x, y, height, region)
  359.     register ScrollBar *sb;
  360.     int x, y, height, region;
  361. {
  362.     register int act;
  363.  
  364.     act = sb->action;
  365.     sb->action = NONE;
  366.     switch(act) {
  367.      case SHOW:
  368.         return;
  369.      case HIDE:
  370.         HideScrollBar(sb);
  371.         return;
  372.     }
  373.     if(!sb->visible)
  374.         return;
  375.     if(sb->regionvisible) {
  376.         XUnmapWindow(sb->region);
  377.         sb->regionvisible = 0;
  378.     }
  379.     XConfigureWindow(sb->bar, x, y, (SCROLLBARWIDTH - 1), height);
  380.     sb->set.height = height - BARSTART;
  381.     sb->set.regionheight = region;
  382.     DrawScrollRegion(sb);
  383. }
  384.  
  385. PositionRegion(sb, y)
  386.     register ScrollBar *sb;
  387.     register int y;
  388. {
  389.     if(y <= BARSTART)
  390.         sb->set.value = sb->set.topvalue;
  391.     else if(y >= BARSTART + sb->set.height *
  392.      (sb->set.bottomvalue - sb->set.topvalue) /
  393.      (sb->set.bottomvalue + sb->set.regionheight - sb->set.topvalue))
  394.         sb->set.value = sb->set.bottomvalue;
  395.     else
  396.         sb->set.value = sb->set.topvalue + (y - BARSTART) *
  397.          (sb->set.bottomvalue + sb->set.regionheight - sb->set.topvalue)
  398.          / sb->set.height;
  399.     DrawScrollRegion(sb);
  400.     return(sb->state.value);
  401. }
  402.  
  403. ButtonRegion(sb)
  404.     register ScrollBar *sb;
  405. {
  406.     register int reverse, pagesize;
  407.  
  408.     if(!(sb->buttonset & HILITED))
  409.         return(sb->set.value);
  410.     reverse = (sb->set.bottomvalue > sb->set.topvalue);
  411.     pagesize = sb->set.regionheight - 1;
  412.     switch(sb->buttonset) {
  413.      case BUTTON_UPLINEHI:
  414.         if(reverse)
  415.             sb->set.value--;
  416.         else
  417.             sb->set.value++;
  418.         break;
  419.      case BUTTON_DOWNLINEHI:
  420.         if(reverse)
  421.             sb->set.value++;
  422.         else
  423.             sb->set.value--;
  424.         break;
  425.      case BUTTON_UPPAGEHI:
  426.         if(reverse)
  427.             sb->set.value -= pagesize;
  428.         else
  429.             sb->set.value += pagesize;
  430.         break;
  431.      case BUTTON_DOWNPAGEHI:
  432.         if(reverse)
  433.             sb->set.value += pagesize;
  434.         else
  435.             sb->set.value -= pagesize;
  436.         break;
  437.      case BUTTON_TOPHI:
  438.         sb->set.value = sb->set.topvalue;
  439.         break;
  440.      case BUTTON_BOTTOMHI:
  441.         sb->set.value = sb->set.bottomvalue;
  442.     }
  443.     DrawScrollRegion(sb);
  444.     return(sb->set.value);
  445. }
  446.  
  447. DownButtonDown(term, reply, pty)
  448.     Terminal *term;
  449.     register XKeyOrButtonEvent *reply;
  450.     int pty;            /* file descriptor of pty */
  451. {
  452.     register Screen *screen = &term->screen;
  453.     register ScrollBar *sb = screen->sb;
  454.     register Window window = reply->subwindow;
  455.  
  456.     if(!window || window == sb->region) {
  457.         WindowScroll(screen, PositionRegion(sb, reply->y));
  458.         return;
  459.     }
  460.     if(window == sb->save) {
  461.         SetSaveState(sb, !GetSaveState(sb));
  462.         return;
  463.     }
  464.     if(window != sb->button || !XGrabMouse(sb->button, sb->cursor,
  465.      ButtonReleased | EnterWindow | LeaveWindow)) {
  466.         Bell();
  467.         return;
  468.     }
  469.     if(reply->detail & ControlMask)
  470.         sb->buttonset = BUTTON_BOTTOMHI;
  471.     else if(reply->detail & ShiftMask)
  472.         sb->buttonset = BUTTON_DOWNPAGEHI;
  473.     else {
  474.         sb->buttonset = BUTTON_DOWNLINEHI;
  475.         stepspeed.tv_usec = PAUSETIME;
  476.         screen->timeout = &stepspeed;
  477.         WindowScroll(screen, ButtonRegion(screen->sb));
  478.     }
  479.     DrawButton(sb);
  480. }
  481.  
  482. UpButtonDown(term, reply, pty)
  483.     Terminal *term;
  484.     register XKeyOrButtonEvent *reply;
  485.     int pty;            /* file descriptor of pty */
  486. {
  487.     register Screen *screen = &term->screen;
  488.     register ScrollBar *sb = screen->sb;
  489.     register Window window = reply->subwindow;
  490.  
  491.     if(!window || window == sb->region) {
  492.         WindowScroll(screen, PositionRegion(sb, reply->y));
  493.         return;
  494.     }
  495.     if(window == sb->save) {
  496.         SetSaveState(sb, !GetSaveState(sb));
  497.         return;
  498.     }
  499.     if(window != sb->button || !XGrabMouse(sb->button, sb->cursor,
  500.      ButtonReleased | EnterWindow | LeaveWindow)) {
  501.         Bell();
  502.         return;
  503.     }
  504.     if(reply->detail & ControlMask)
  505.         sb->buttonset = BUTTON_TOPHI;
  506.     else if(reply->detail & ShiftMask)
  507.         sb->buttonset = BUTTON_UPPAGEHI;
  508.     else {
  509.         sb->buttonset = BUTTON_UPLINEHI;
  510.         stepspeed.tv_usec = PAUSETIME;
  511.         screen->timeout = &stepspeed;
  512.         WindowScroll(screen, ButtonRegion(screen->sb));
  513.     }
  514.     DrawButton(sb);
  515. }
  516.  
  517. ButtonUp(term, reply, pty)
  518.     Terminal *term;
  519.     XKeyOrButtonEvent *reply;
  520.     int pty;            /* file descriptor of pty */
  521. {
  522.     register Screen *screen = &term->screen;
  523.     register ScrollBar *sb = screen->sb;
  524.     register int state;
  525.  
  526.     if((state = GetButtonState(sb)) == BUTTON_NORMAL)
  527.         return;
  528.     /* don't scroll further on line mode */
  529.     if(state > BUTTON_DOWNLINEHI)
  530.         WindowScroll(screen, ButtonRegion(sb));
  531.     sb->buttonset = BUTTON_NORMAL;
  532.     DrawButton(sb);
  533.     screen->timeout = NULL;
  534.     XUngrabMouse();
  535. }
  536.  
  537. WindowScroll(screen, top)
  538.     register Screen *screen;
  539.     int top;
  540. {
  541.     register int i, lines;
  542.     register int scrolltop, scrollheight, refreshtop;
  543.  
  544.     if((i = screen->topline - top) == 0)
  545.         return;
  546.     if(screen->cursor_state)
  547.         HideCursor();
  548.     lines = i > 0 ? i : -i;
  549.     if(lines > screen->max_row + 1)
  550.         lines = screen->max_row + 1;
  551.     scrollheight = screen->max_row - lines + 1;
  552.     if(i > 0)
  553.         refreshtop = scrolltop = 0;
  554.     else {
  555.         scrolltop = lines;
  556.         refreshtop = scrollheight;
  557.     }
  558.     if(scrollheight > 0) {
  559.         if (screen->multiscroll && scrollheight == 1 &&
  560.          screen->topline == 0 && screen->top_marg == 0 &&
  561.          screen->bot_marg == screen->max_row) {
  562.             if (screen->incopy < 0 && screen->scrolls == 0)
  563.                 CopyWait (screen);
  564.             screen->scrolls++;
  565.         } else {
  566.             if (screen->incopy)
  567.                 CopyWait (screen);
  568.             screen->incopy = -1;
  569.         }
  570.         XMoveArea(VWindow(screen), screen->border, scrolltop *
  571.          FontHeight(screen) + screen->border + Titlebar(screen),
  572.          screen->border, (scrolltop + i) * FontHeight(screen) +
  573.          screen->border + Titlebar(screen), Width(screen),
  574.          scrollheight * FontHeight(screen));
  575.     }
  576.     screen->topline = top;
  577.     XTileSet(VWindow(screen), screen->border, refreshtop * FontHeight(screen) +
  578.      screen->border + Titlebar(screen), Width(screen), lines *
  579.      FontHeight(screen), screen->bgndtile);
  580.     ScrnRefresh(screen, refreshtop, 0, lines, screen->max_col + 1);
  581. }
  582.  
  583. ScrollBarOn(screen, show, init)
  584.     register Screen *screen;
  585.     int show, init;
  586. {
  587.     register int border = 2 * screen->border;
  588.     register int i;
  589.     char *realloc(), *calloc();
  590.  
  591.     if(screen->scrollbar)
  592.         return;
  593.     if(!screen->sb) {
  594.         if((screen->sb = CreateScrollBar(VWindow(screen),
  595.          Width(screen) + border, Titlebar(screen) - 1,
  596.          Height(screen) + border, screen->foreground,
  597.          screen->background, screen->bordertile, 0,
  598.          screen->max_row + 1, 0, 0, screen->arrow)) == NULL) {
  599.             Bell();
  600.             return;
  601.         }
  602.         if((screen->allbuf = (ScrnBuf) realloc(screen->buf,
  603.          2*(screen->max_row + 2 + screen->savelines) * sizeof(char *)))
  604.          == NULL)
  605.             Error (ERROR_SBRALLOC);
  606.         screen->buf = &screen->allbuf[2 * screen->savelines];
  607.         bcopy ((char *)screen->allbuf, (char *)screen->buf,
  608.          2 * (screen->max_row + 2) * sizeof (char *));
  609.         for(i = 2 * screen->savelines - 1 ; i >= 0 ; i--)
  610.             if((screen->allbuf[i] =
  611.              calloc(screen->max_col + 1, sizeof(char))) == NULL)
  612.                 Error (ERROR_SBRALLOC2);
  613.         screen->sb->saveset = !screen->alternate;
  614.     } else {
  615.         XConfigureWindow(screen->sb->bar, FullWidth(screen),
  616.          Titlebar(screen) - 1, (SCROLLBARWIDTH - 1),
  617.          i = FullHeight(screen) - Titlebar(screen));
  618.         screen->sb->set.height = i - BARSTART;
  619.         screen->sb->set.regionheight = screen->max_row + 1;
  620.     }
  621.     if(show) {
  622.         screen->scrollbar = SCROLLBARWIDTH;
  623.         ShowScrollBar(screen->sb);
  624.         if(!init) {
  625.             XSetResizeHint(VWindow(screen), border + SCROLLBARWIDTH,
  626.              border + Titlebar(screen) + screen->statusheight,
  627.              FontWidth(screen), FontHeight(screen));
  628.             XChangeWindow(VWindow(screen), (screen->max_col + 1) *
  629.              FontWidth(screen) + border + SCROLLBARWIDTH,
  630.              FontHeight(screen) * (screen->max_row + 1) +
  631.              screen->statusheight + border + Titlebar(screen));
  632.         }
  633.     }
  634. }
  635.  
  636. ScrollBarOff(screen)
  637.     register Screen *screen;
  638. {
  639.     register int border = 2 * screen->border;
  640.  
  641.     if(!screen->scrollbar)
  642.         return;
  643.     screen->sb->action = HIDE;
  644.     screen->scrollbar = 0;
  645.     XSetResizeHint(VWindow(screen), border, border + Titlebar(screen) +
  646.      screen->statusheight, FontWidth(screen), FontHeight(screen));
  647.     XChangeWindow(VWindow(screen), (screen->max_col + 1) * FontWidth(screen) +
  648.      border, FontHeight(screen) * (screen->max_row + 1) + screen->statusheight
  649.      + border + Titlebar(screen));
  650. }
  651.  
  652. ClearLinesOffTop(screen)
  653.     register Screen *screen;
  654. {
  655.     if(!screen->sb)
  656.         return;
  657.     if(screen->topline)
  658.         WindowScroll(screen, 0);
  659.     SetScrollBarTop(screen->sb, 0);
  660.     DrawScrollRegion(screen->sb);
  661. }
  662.  
  663. SetSaveState(sb, state)
  664.     register ScrollBar *sb;
  665.     int state;
  666. {
  667.     extern Terminal term;
  668.     register Screen *screen = &term.screen;
  669.  
  670.     if(screen->alternate)
  671.         return;
  672.     if(screen->scroll_amt)
  673.         FlushScroll(screen);
  674.     sb->saveset = state;
  675.     DrawSave(sb);
  676. }
  677.  
  678. SetButtonState(sb, state)
  679.     register ScrollBar *sb;
  680.     int state;
  681. {
  682.     sb->buttonset = state;
  683.     DrawButton(sb);
  684. }
  685.  
  686. static Window
  687. Make_tiled_window(bitmap_width, bitmap_height, bitmap_bits, foreground,
  688.  background, bgnd, parent, x, y, width, height, borderwidth, bordertile)
  689.     int bitmap_width, bitmap_height, foreground, background, x, y, width,
  690.      height, borderwidth;
  691.     short *bitmap_bits;
  692.     Window parent;
  693.     Pixmap *bgnd, bordertile;
  694. {
  695.     register Pixmap pix;
  696.     register Window w;
  697.     extern Pixmap Make_tile();
  698.  
  699.     if((pix = Make_tile(bitmap_width, bitmap_height, bitmap_bits,
  700.      foreground, background)) == NULL)
  701.         return(NULL);
  702.     w = XCreateWindow(parent, x, y, width, height, borderwidth, bordertile,
  703.      pix);
  704.     *bgnd = pix;
  705.     return(w);
  706. }
  707.  
  708. Pixmap
  709. Make_tile(bitmap_width, bitmap_height, bitmap_bits, foreground, background)
  710.     int bitmap_width, bitmap_height, foreground, background;
  711.     short *bitmap_bits;
  712. {
  713.     register Bitmap bm;
  714.     register Pixmap pix;
  715.  
  716.     if((bm = XStoreBitmap(bitmap_width, bitmap_height, bitmap_bits))
  717.      == NULL)
  718.         return(NULL);
  719.     pix = XMakePixmap(bm, foreground, background);
  720.     XFreeBitmap(bm);
  721.     return(pix);
  722. }
  723.  
  724. ScrollToBottom(sb)
  725. register ScrollBar *sb;
  726. {
  727.     SetScrollBarValue(sb, GetScrollBarBottom(sb));
  728.     DrawScrollRegion(sb);
  729.     WindowScroll(&term.screen, GetScrollBarValue(sb));
  730. }
  731.  
  732. #ifdef MODEMENU
  733. #define    SMENU_SCROLLKEY    0
  734. #define    SMENU_SCROLLINPUT (SMENU_SCROLLKEY+1)
  735. #define    SMENU_LINESTOP    (SMENU_SCROLLINPUT+1)
  736. #define    SMENU_LINE    (SMENU_LINESTOP+1)
  737. #define    SMENU_CLEARTOP    (SMENU_LINE+1)
  738. #define    SMENU_HIDE    (SMENU_CLEARTOP+1)
  739.  
  740. static char *stext[] = {
  741.     "Scroll to Bottom on Key",
  742.     "Scroll to Bottom on Input",
  743.     "Lines Off Top Saved",
  744.     "-",
  745.     "Clear Lines Off Top",
  746.     "Hide Scrollbar",
  747.     0,
  748. };
  749.  
  750.  
  751. static int salternate;
  752. static int slinestop;
  753. static int sscrollinput;
  754. static int sscrollkey;
  755.  
  756. Menu *ssetupmenu(menu)
  757. register Menu **menu;
  758. {
  759.     register Screen *screen = &term.screen;
  760.     register char **cp;
  761.  
  762.     if (*menu == NULL) {
  763.         if ((*menu = NewMenu("Scrollbar", re_verse)) == NULL)
  764.             return(NULL);
  765.         for(cp = stext ; *cp ; cp++)
  766.             AddMenuItem(*menu, *cp);
  767.         if(sscrollkey = screen->scrollkey)
  768.             CheckItem(*menu, SMENU_SCROLLKEY);
  769.         if(sscrollinput = screen->scrollinput)
  770.             CheckItem(*menu, SMENU_SCROLLINPUT);
  771.         if(slinestop = (screen->sb && GetSaveState(screen->sb)))
  772.             CheckItem(*menu, SMENU_LINESTOP);
  773.         if(salternate = screen->alternate)
  774.             DisableItem(*menu, SMENU_LINESTOP);
  775.         DisableItem(*menu, SMENU_LINE);
  776.         return(*menu);
  777.     }
  778.     if(sscrollkey != screen->scrollkey)
  779.         SetItemCheck(*menu, SMENU_SCROLLKEY, (sscrollkey =
  780.          screen->scrollkey));
  781.     if(sscrollinput != screen->scrollinput)
  782.         SetItemCheck(*menu, SMENU_SCROLLINPUT, (sscrollinput =
  783.          screen->scrollinput));
  784.     if(screen->sb && slinestop != GetSaveState(screen->sb))
  785.         SetItemCheck(*menu, SMENU_LINESTOP, (slinestop =
  786.          GetSaveState(screen->sb)));
  787.     if(salternate != screen->alternate)
  788.         SetItemDisable(*menu, SMENU_LINESTOP, (salternate =
  789.          screen->alternate));
  790.     return(*menu);
  791. }
  792.  
  793. sdomenufunc(item)
  794. int item;
  795. {
  796.     register Screen *screen = &term.screen;
  797.  
  798.     switch (item) {
  799.      case SMENU_SCROLLKEY:
  800.         screen->scrollkey = !screen->scrollkey;
  801.         break;
  802.  
  803.      case SMENU_SCROLLINPUT:
  804.         screen->scrollinput = !screen->scrollinput;
  805.         break;
  806.  
  807.      case SMENU_LINESTOP:
  808.         SetSaveState(screen->sb, !GetSaveState(screen->sb));
  809.         break;
  810.  
  811.      case SMENU_CLEARTOP:
  812.         ClearLinesOffTop(screen);
  813.         break;
  814.  
  815.      case SMENU_HIDE:
  816.         ScrollBarOff(screen);
  817.         break;
  818.     }
  819. }
  820. #endif MODEMENU
  821. RAZZLE!DAZZLE
  822. fi    # End scrollbar.c
  823. if test -f tabs.c
  824. then
  825.     echo shar: will not overwrite existing file "'tabs.c'"
  826. else
  827. echo 'x - tabs.c'
  828. cat << \RAZZLE!DAZZLE > tabs.c
  829. /*
  830.  *    $Source: /u1/X/xterm/RCS/tabs.c,v $
  831.  *    $Header: tabs.c,v 10.100 86/12/01 14:45:38 jg Rel $
  832.  */
  833.  
  834. #ifndef lint
  835. static char *rcsid_tabs_c = "$Header: tabs.c,v 10.100 86/12/01 14:45:38 jg Rel $";
  836. #endif    lint
  837.  
  838. #include <X/mit-copyright.h>
  839.  
  840. /* Copyright    Massachusetts Institute of Technology    1984    */
  841.  
  842. /* tabs.c */
  843.  
  844. #ifndef lint
  845. /* @(#)tabs.c       X10/6.6B 12/26/86 */
  846. #endif    lint
  847.  
  848. #include <X/Xlib.h>
  849. #include "scrollbar.h"
  850. #include "ptyx.h"
  851. /*
  852.  * This file presumes 32bits/word.  This is somewhat of a crock, and should
  853.  * be fixed sometime.
  854.  */
  855.  
  856. /*
  857.  * places tabstops at only every 8 columns
  858.  */
  859. TabReset(tabs)
  860. Tabs    tabs;
  861. {
  862.     register int i;
  863.  
  864.     for (i=0; i<TAB_ARRAY_SIZE; ++i)
  865.         tabs[i] = 0;
  866.  
  867.     for (i=0; i<MAX_TABS; i+=8)
  868.         TabSet(tabs, i);
  869. }    
  870.  
  871.  
  872. /*
  873.  * places a tabstop at col
  874.  */
  875. TabSet(tabs, col)
  876. Tabs    tabs;
  877. {
  878.     tabs[col >> 5] |= (1 << (col & 31));
  879. }
  880.  
  881. /*
  882.  * clears a tabstop at col
  883.  */
  884. TabClear(tabs, col)
  885. Tabs    tabs;
  886. {
  887.     tabs[col >> 5] &= ~(1 << (col & 31));
  888. }
  889.  
  890. /*
  891.  * returns the column of the next tabstop
  892.  * (or MAX_TABS - 1 if there are no more).
  893.  * A tabstop at col is ignored.
  894.  */
  895. TabNext (tabs, col)
  896. Tabs    tabs;
  897. {
  898.     extern Terminal term;
  899.     register Screen *screen = &term.screen;
  900.  
  901.     if(screen->curses && screen->do_wrap && (term.flags & WRAPAROUND)) {
  902.         Index(screen, 1);
  903.         col = screen->cur_col = screen->do_wrap = 0;
  904.     }
  905.     for (++col; col<MAX_TABS; ++col)
  906.         if (tabs[col >> 5] & (1 << (col & 31)))
  907.             return (col);
  908.  
  909.     return (MAX_TABS - 1);
  910. }
  911.  
  912. /*
  913.  * clears all tabs
  914.  */
  915. TabZonk (tabs)
  916. Tabs    tabs;
  917. {
  918.     register int i;
  919.  
  920.     for (i=0; i<TAB_ARRAY_SIZE; ++i)
  921.         tabs[i] = 0;
  922. }
  923. RAZZLE!DAZZLE
  924. fi    # End tabs.c
  925. if test -f termcap
  926. then
  927.     echo shar: will not overwrite existing file "'termcap'"
  928. else
  929. echo 'x - termcap'
  930. cat << \RAZZLE!DAZZLE > termcap
  931. # @(#)termcap       X10/6.6B 12/26/86
  932. vs|xterm|vs100|xterm terminal emulator (X window system):\
  933.     :cr=^M:do=^J:nl=^J:bl=^G:le=^H:ho=\E[H:\
  934.     :co#80:li#65:cl=\E[H\E[2J:bs:am:cm=\E[%i%d;%dH:nd=\E[C:up=\E[A:\
  935.     :ce=\E[K:cd=\E[J:so=\E[7m:se=\E[m:us=\E[4m:ue=\E[m:\
  936.     :md=\E[1m:mr=\E[7m:me=\E[m:\
  937.     :ku=\EOA:kd=\EOB:kr=\EOC:kl=\EOD:kb=^H:\
  938.     :k1=\EOP:k2=\EOQ:k3=\EOR:k4=\EOS:ta=^I:pt:sf=\n:sr=\EM:\
  939.     :al=\E[L:dl=\E[M:ic=\E[@:dc=\E[P:\
  940.     :MT:ks=\E[?1h\E=:ke=\E[?1l\E>:\
  941.     :is=\E[r\E[m\E[2J\E[H\E[?7h\E[?1;3;4;6l:\
  942.     :rs=\E[r\E<\E[m\E[2J\E[H\E[?7h\E[?1;3;4;6l:xn:\
  943.     :AL=\E[%dL:DL=\E[%dM:IC=\E[%d@:DC=\E[%dP:\
  944.     :ti=\E7\E[?47h:te=\E[2J\E[?47l\E8:\
  945.     :hs:ts=\E[?E\E[?%i%dT:fs=\E[?F:es:ds=\E[?E:
  946. v2|xterms|vs100s|xterm terminal emulator (small)(X window system):\
  947.     :co#80:li#24:tc=xterm:
  948. RAZZLE!DAZZLE
  949. fi    # End termcap
  950. if test -f terminfo
  951. then
  952.     echo shar: will not overwrite existing file "'terminfo'"
  953. else
  954. echo 'x - terminfo'
  955. cat << \RAZZLE!DAZZLE > terminfo
  956. # @(#)terminfo       X10/6.6B 12/26/86
  957. xterm|vs100|xterm terminal emulator,
  958.     ind=^J, cols#80, lines#65,
  959.     clear=\E[H\E[2J, cub1=^H, am, cup=\E[%i%p1%d;%p2%dH,
  960.     cuf1=\E[C, cuu1=\E[A, el=\E[K, ed=\E[J,
  961.     cud=\E[%p1%dB, cuu=\E[%p1%dA, cub=\E[%p1%dD,
  962.     cuf=\E[%p1%dC, km,
  963.     smso=\E[7m, rmso=\E[m, smul@, rmul@,
  964.     bold=\E[1m, rev=\E[7m, blink=@, sgr0=\E[m,
  965.     rs1=\E>\E[1;3;4;5;6l\E[?7h\E[m\E[r\E[2J\E[H, rs2=@
  966.     kf1=\EOP, kf2=\EOQ, kf3=\EOR, kf4=\EOS, ht=^I, ri=\EM,
  967.     vt@, xon@, csr=\E[%i%p1%d;%p2%dr,
  968.     il=\E[%p1%dL, dl=\E[%p1%dM, il1=\E[L, dl1=\E[M,
  969.     ich=\E[%p1%d@, dch=\E[%p1%dP, ich1=\E[@, dch1=\E[P,
  970.     use=vt100-am,
  971. xterms|vs100s|xterm terminal emulator (small screen 24x80),
  972.     cols#80, lines#24,
  973.     use=xterm,
  974. RAZZLE!DAZZLE
  975. fi    # End terminfo
  976. if test -f util.c
  977. then
  978.     echo shar: will not overwrite existing file "'util.c'"
  979. else
  980. echo 'x - util.c'
  981. cat << \RAZZLE!DAZZLE > util.c
  982. /*
  983.  *    $Source: /u1/X/xterm/RCS/util.c,v $
  984.  *    $Header: util.c,v 10.100 86/12/01 14:45:43 jg Rel $
  985.  */
  986.  
  987. #include <X/mit-copyright.h>
  988.  
  989. /* Copyright    Massachusetts Institute of Technology    1984, 1985    */
  990.  
  991. /* util.c */
  992.  
  993. #ifndef lint
  994. static char sccs_id[] = "@(#)util.c\tX10/6.6B\t12/26/86";
  995. #endif    lint
  996.  
  997. #include <stdio.h>
  998. #include <X/Xlib.h>
  999. #include <signal.h>
  1000. #include <setjmp.h>
  1001. typedef int *jmp_ptr;
  1002.  
  1003. #include "scrollbar.h"
  1004. #include "ptyx.h"
  1005. #include "data.h"
  1006. #include "error.h"
  1007.  
  1008. /*
  1009.  * These routines are used for the jump scroll feature
  1010.  */
  1011. FlushScroll(screen)
  1012. register Screen *screen;
  1013. {
  1014.     register int i;
  1015.     register int shift = -screen->topline;
  1016.     register int bot = screen->max_row - shift;
  1017.     register int refreshtop;
  1018.     register int refreshheight;
  1019.     register int scrolltop;
  1020.     register int scrollheight;
  1021.  
  1022.     if(screen->cursor_state)
  1023.         HideCursor();
  1024.     if(screen->scroll_amt > 0) {
  1025.         refreshheight = screen->refresh_amt;
  1026.         scrollheight = screen->bot_marg - screen->top_marg -
  1027.          refreshheight + 1;
  1028.         if((refreshtop = screen->bot_marg - refreshheight + 1 + shift) >
  1029.          (i = screen->max_row - screen->scroll_amt + 1))
  1030.             refreshtop = i;
  1031.         if(screen->sb && GetSaveState(screen->sb) &&
  1032.          screen->top_marg == 0) {
  1033.             scrolltop = 0;
  1034.             if((scrollheight += shift) > i)
  1035.                 scrollheight = i;
  1036.             if((i = screen->bot_marg - bot) > 0 &&
  1037.              (refreshheight -= i) < screen->scroll_amt)
  1038.                 refreshheight = screen->scroll_amt;
  1039.             if((i = -GetScrollBarTop(screen->sb)) <
  1040.              screen->savelines) {
  1041.                 if((i += screen->scroll_amt) >
  1042.                  screen->savelines)
  1043.                     i = screen->savelines;
  1044.                 SetScrollBarTop(screen->sb, -i);
  1045.                 DrawScrollRegion(screen->sb);
  1046.             }
  1047.         } else {
  1048.             scrolltop = screen->top_marg + shift;
  1049.             if((i = bot - (screen->bot_marg - screen->refresh_amt +
  1050.              screen->scroll_amt)) > 0) {
  1051.                 if(bot < screen->bot_marg)
  1052.                     refreshheight = screen->scroll_amt + i;
  1053.             } else {
  1054.                 scrollheight += i;
  1055.                 refreshheight = screen->scroll_amt;
  1056.                 if((i = screen->top_marg + screen->scroll_amt -
  1057.                  1 - bot) > 0) {
  1058.                     refreshtop += i;
  1059.                     refreshheight -= i;
  1060.                 }
  1061.             }
  1062.         }
  1063.     } else {
  1064.         refreshheight = -screen->refresh_amt;
  1065.         scrollheight = screen->bot_marg - screen->top_marg -
  1066.          refreshheight + 1;
  1067.         refreshtop = screen->top_marg + shift;
  1068.         scrolltop = refreshtop + refreshheight;
  1069.         if((i = screen->bot_marg - bot) > 0)
  1070.             scrollheight -= i;
  1071.         if((i = screen->top_marg + refreshheight - 1 - bot) > 0)
  1072.             refreshheight -= i;
  1073.     }
  1074.     if(scrollheight > 0) {
  1075.         if (screen->multiscroll && scrollheight == 1 &&
  1076.          screen->topline == 0 && screen->top_marg == 0 &&
  1077.          screen->bot_marg == screen->max_row) {
  1078.             if (screen->incopy < 0 && screen->scrolls == 0)
  1079.                 CopyWait (screen);
  1080.             screen->scrolls++;
  1081.         } else {
  1082.             if (screen->incopy)
  1083.                 CopyWait (screen);
  1084.             screen->incopy = -1;
  1085.         }
  1086.  
  1087.         XMoveArea (VWindow(screen), screen->border, (scrolltop +
  1088.          screen->scroll_amt) * FontHeight(screen) + screen->border +
  1089.          Titlebar(screen), screen->border, scrolltop * FontHeight(screen)
  1090.          + screen->border + Titlebar(screen), Width(screen),
  1091.          scrollheight * FontHeight(screen));
  1092.     }
  1093.     screen->scroll_amt = 0;
  1094.     screen->refresh_amt = 0;
  1095.     if(refreshheight > 0) {
  1096.         XTileSet (VWindow(screen), screen->border, refreshtop *
  1097.          FontHeight(screen) + screen->border + Titlebar(screen),
  1098.          Width(screen), refreshheight * FontHeight(screen),
  1099.          screen->bgndtile);
  1100.         ScrnRefresh(screen, refreshtop, 0, refreshheight,
  1101.          screen->max_col + 1);
  1102.     }
  1103. }
  1104.  
  1105. AddToRefresh(screen)
  1106. register Screen *screen;
  1107. {
  1108.     register int amount = screen->refresh_amt;
  1109.     register int row = screen->cur_row;
  1110.  
  1111.     if(amount == 0 || screen->instatus)
  1112.         return(0);
  1113.     if(amount > 0) {
  1114.         register int bottom;
  1115.  
  1116.         if(row == (bottom = screen->bot_marg) - amount) {
  1117.             screen->refresh_amt++;
  1118.             return(1);
  1119.         }
  1120.         return(row >= bottom - amount + 1 && row <= bottom);
  1121.     } else {
  1122.         register int top;
  1123.  
  1124.         amount = -amount;
  1125.         if(row == (top = screen->top_marg) + amount) {
  1126.             screen->refresh_amt--;
  1127.             return(1);
  1128.         }
  1129.         return(row <= top + amount - 1 && row >= top);
  1130.     }
  1131. }
  1132.  
  1133. /* 
  1134.  * scrolls the screen by amount lines, erases bottom, doesn't alter 
  1135.  * cursor position (i.e. cursor moves down amount relative to text).
  1136.  * All done within the scrolling region, of course. 
  1137.  * requires: amount > 0
  1138.  */
  1139. Scroll (screen, amount)
  1140. register Screen *screen;
  1141. register int amount;
  1142. {
  1143.     register int i = screen->bot_marg - screen->top_marg + 1;
  1144.     register int shift;
  1145.     register int bot;
  1146.     register int refreshtop;
  1147.     register int refreshheight;
  1148.     register int scrolltop;
  1149.     register int scrollheight;
  1150.  
  1151.     if(screen->cursor_state)
  1152.         HideCursor();
  1153.     if (amount > i)
  1154.         amount = i;
  1155.     if(screen->jumpscroll) {
  1156.     if(screen->scroll_amt > 0) {
  1157.         if(screen->refresh_amt + amount > i)
  1158.             FlushScroll(screen);
  1159.         screen->scroll_amt += amount;
  1160.         screen->refresh_amt += amount;
  1161.     } else {
  1162.         if(screen->scroll_amt < 0)
  1163.             FlushScroll(screen);
  1164.         screen->scroll_amt = amount;
  1165.         screen->refresh_amt = amount;
  1166.     }
  1167.     refreshheight = 0;
  1168.     } else {
  1169.  
  1170.     if (amount == i) {
  1171.         ClearScreen(screen);
  1172.         return;
  1173.     }
  1174.     shift = -screen->topline;
  1175.     bot = screen->max_row - shift;
  1176.     scrollheight = i - amount;
  1177.     refreshheight = amount;
  1178.     if((refreshtop = screen->bot_marg - refreshheight + 1 + shift) >
  1179.      (i = screen->max_row - refreshheight + 1))
  1180.         refreshtop = i;
  1181.     if(screen->sb && GetSaveState(screen->sb) && screen->top_marg == 0) {
  1182.         scrolltop = 0;
  1183.         if((scrollheight += shift) > i)
  1184.             scrollheight = i;
  1185.         if((i = -GetScrollBarTop(screen->sb)) < screen->savelines) {
  1186.             if((i += amount) > screen->savelines)
  1187.                 i = screen->savelines;
  1188.             SetScrollBarTop(screen->sb, -i);
  1189.             DrawScrollRegion(screen->sb);
  1190.         }
  1191.     } else {
  1192.         scrolltop = screen->top_marg + shift;
  1193.         if((i = screen->bot_marg - bot) > 0) {
  1194.             scrollheight -= i;
  1195.             if((i = screen->top_marg + amount - 1 - bot) >= 0) {
  1196.                 refreshtop += i;
  1197.                 refreshheight -= i;
  1198.             }
  1199.         }
  1200.     }
  1201.     if(scrollheight > 0) {
  1202.         if (screen->multiscroll
  1203.         && amount==1 && screen->topline == 0
  1204.         && screen->top_marg==0
  1205.         && screen->bot_marg==screen->max_row) {
  1206.             if (screen->incopy<0 && screen->scrolls==0)
  1207.                 CopyWait(screen);
  1208.             screen->scrolls++;
  1209.         } else {
  1210.             if (screen->incopy)
  1211.                 CopyWait(screen);
  1212.             screen->incopy = -1;
  1213.         }
  1214.  
  1215.         XMoveArea(VWindow(screen), screen->border, (scrolltop+amount) *
  1216.          FontHeight(screen) + screen->border + Titlebar(screen),
  1217.          screen->border, scrolltop * FontHeight(screen) + screen->border
  1218.          + Titlebar(screen), Width(screen), scrollheight *
  1219.          FontHeight(screen));
  1220.     }
  1221.     if(refreshheight > 0) {
  1222.         XTileSet (VWindow(screen), screen->border, refreshtop *
  1223.          FontHeight(screen) + screen->border + Titlebar(screen),
  1224.          Width(screen), refreshheight * FontHeight(screen),
  1225.          screen->bgndtile);
  1226.         if(refreshheight > shift)
  1227.             refreshheight = shift;
  1228.     }
  1229.     }
  1230.     if(screen->sb && GetSaveState(screen->sb) && screen->top_marg == 0)
  1231.         ScrnDeleteLine(screen->allbuf, screen->bot_marg +
  1232.          screen->savelines, 0, amount, screen->max_col + 1);
  1233.     else
  1234.         ScrnDeleteLine(screen->buf, screen->bot_marg, screen->top_marg,
  1235.          amount, screen->max_col + 1);
  1236.     if(refreshheight > 0)
  1237.         ScrnRefresh(screen, refreshtop, 0, refreshheight,
  1238.          screen->max_col + 1);
  1239. }
  1240.  
  1241.  
  1242. /*
  1243.  * Reverse scrolls the screen by amount lines, erases top, doesn't alter
  1244.  * cursor position (i.e. cursor moves up amount relative to text).
  1245.  * All done within the scrolling region, of course.
  1246.  * Requires: amount > 0
  1247.  */
  1248. RevScroll(screen, amount)
  1249. register Screen *screen;
  1250. register int amount;
  1251. {
  1252.     register int i = screen->bot_marg - screen->top_marg + 1;
  1253.     register int shift;
  1254.     register int bot;
  1255.     register int refreshtop;
  1256.     register int refreshheight;
  1257.     register int scrolltop;
  1258.     register int scrollheight;
  1259.  
  1260.     if(screen->cursor_state)
  1261.         HideCursor();
  1262.     if (amount > i)
  1263.         amount = i;
  1264.     if(screen->jumpscroll) {
  1265.     if(screen->scroll_amt < 0) {
  1266.         if(-screen->refresh_amt + amount > i)
  1267.             FlushScroll(screen);
  1268.         screen->scroll_amt -= amount;
  1269.         screen->refresh_amt -= amount;
  1270.     } else {
  1271.         if(screen->scroll_amt > 0)
  1272.             FlushScroll(screen);
  1273.         screen->scroll_amt = -amount;
  1274.         screen->refresh_amt = -amount;
  1275.     }
  1276.     } else {
  1277.     shift = -screen->topline;
  1278.     bot = screen->max_row - shift;
  1279.     refreshheight = amount;
  1280.     scrollheight = screen->bot_marg - screen->top_marg -
  1281.      refreshheight + 1;
  1282.     refreshtop = screen->top_marg + shift;
  1283.     scrolltop = refreshtop + refreshheight;
  1284.     if((i = screen->bot_marg - bot) > 0)
  1285.         scrollheight -= i;
  1286.     if((i = screen->top_marg + refreshheight - 1 - bot) > 0)
  1287.         refreshheight -= i;
  1288.     if(scrollheight > 0) {
  1289.         if (screen->multiscroll
  1290.         && amount==1 && screen->topline == 0
  1291.         && screen->top_marg==0
  1292.         && screen->bot_marg==screen->max_row) {
  1293.             if (screen->incopy<0 && screen->scrolls==0)
  1294.                 CopyWait(screen);
  1295.             screen->scrolls++;
  1296.         } else {
  1297.             if (screen->incopy)
  1298.                 CopyWait(screen);
  1299.             screen->incopy = -1;
  1300.         }
  1301.  
  1302.         XMoveArea (VWindow(screen), screen->border, (scrolltop-amount) *
  1303.          FontHeight(screen) + screen->border + Titlebar(screen),
  1304.          screen->border, scrolltop * FontHeight(screen) + screen->border
  1305.          + Titlebar(screen), Width(screen), scrollheight *
  1306.          FontHeight(screen));
  1307.     }
  1308.     if(refreshheight > 0)
  1309.         XTileSet (VWindow(screen), screen->border, refreshtop *
  1310.          FontHeight(screen) + screen->border + Titlebar(screen),
  1311.          Width(screen), refreshheight * FontHeight(screen),
  1312.          screen->bgndtile);
  1313.     }
  1314.     ScrnInsertLine (screen->buf, screen->bot_marg, screen->top_marg,
  1315.             amount, screen->max_col + 1);
  1316. }
  1317.  
  1318. /*
  1319.  * If cursor not in scrolling region, returns.  Else,
  1320.  * inserts n blank lines at the cursor's position.  Lines above the
  1321.  * bottom margin are lost.
  1322.  */
  1323. InsertLine (screen, n)
  1324. register Screen *screen;
  1325. register int n;
  1326. {
  1327.     register int i;
  1328.     register int shift;
  1329.     register int bot;
  1330.     register int refreshtop;
  1331.     register int refreshheight;
  1332.     register int scrolltop;
  1333.     register int scrollheight;
  1334.  
  1335.     if (screen->cur_row < screen->top_marg ||
  1336.      screen->cur_row > screen->bot_marg)
  1337.         return;
  1338.     if(screen->cursor_state)
  1339.         HideCursor();
  1340.     screen->do_wrap = 0;
  1341.     if (n > (i = screen->bot_marg - screen->cur_row + 1))
  1342.         n = i;
  1343.     if(screen->jumpscroll) {
  1344.     if(screen->scroll_amt <= 0 &&
  1345.      screen->cur_row <= -screen->refresh_amt) {
  1346.         if(-screen->refresh_amt + n > screen->max_row + 1)
  1347.             FlushScroll(screen);
  1348.         screen->scroll_amt -= n;
  1349.         screen->refresh_amt -= n;
  1350.     } else if(screen->scroll_amt)
  1351.         FlushScroll(screen);
  1352.     }
  1353.     if(!screen->scroll_amt) {
  1354.     shift = -screen->topline;
  1355.     bot = screen->max_row - shift;
  1356.     refreshheight = n;
  1357.     scrollheight = screen->bot_marg - screen->cur_row - refreshheight + 1;
  1358.     refreshtop = screen->cur_row + shift;
  1359.     scrolltop = refreshtop + refreshheight;
  1360.     if((i = screen->bot_marg - bot) > 0)
  1361.         scrollheight -= i;
  1362.     if((i = screen->cur_row + refreshheight - 1 - bot) > 0)
  1363.         refreshheight -= i;
  1364.     if(scrollheight > 0) {
  1365.         if (screen->incopy)
  1366.             CopyWait (screen);
  1367.         screen->incopy = -1;
  1368.         XMoveArea (VWindow(screen), screen->border, (scrolltop - n) *
  1369.          FontHeight(screen) + screen->border + Titlebar(screen),
  1370.          screen->border, scrolltop * FontHeight(screen) + screen->border
  1371.          + Titlebar(screen), Width(screen), scrollheight *
  1372.          FontHeight(screen));
  1373.     }
  1374.     if(refreshheight > 0)
  1375.         XTileSet (VWindow(screen),
  1376.          screen->border, refreshtop * FontHeight(screen) + screen->border
  1377.          + Titlebar(screen), Width(screen), refreshheight *
  1378.          FontHeight(screen), screen->bgndtile);
  1379.     }
  1380.     /* adjust screen->buf */
  1381.     ScrnInsertLine(screen->buf, screen->bot_marg, screen->cur_row, n,
  1382.             screen->max_col + 1);
  1383. }
  1384.  
  1385. /*
  1386.  * If cursor not in scrolling region, returns.  Else, deletes n lines
  1387.  * at the cursor's position, lines added at bottom margin are blank.
  1388.  */
  1389. DeleteLine(screen, n)
  1390. register Screen *screen;
  1391. register int n;
  1392. {
  1393.     register int i;
  1394.     register int shift;
  1395.     register int bot;
  1396.     register int refreshtop;
  1397.     register int refreshheight;
  1398.     register int scrolltop;
  1399.     register int scrollheight;
  1400.  
  1401.     if (screen->cur_row < screen->top_marg ||
  1402.      screen->cur_row > screen->bot_marg)
  1403.         return;
  1404.     if(screen->cursor_state)
  1405.         HideCursor();
  1406.     screen->do_wrap = 0;
  1407.     if (n > (i = screen->bot_marg - screen->cur_row + 1))
  1408.         n = i;
  1409.     if(screen->jumpscroll) {
  1410.     if(screen->scroll_amt >= 0 && screen->cur_row == screen->top_marg) {
  1411.         if(screen->refresh_amt + n > screen->max_row + 1)
  1412.             FlushScroll(screen);
  1413.         screen->scroll_amt += n;
  1414.         screen->refresh_amt += n;
  1415.     } else if(screen->scroll_amt)
  1416.         FlushScroll(screen);
  1417.     }
  1418.     if(!screen->scroll_amt) {
  1419.  
  1420.     shift = -screen->topline;
  1421.     bot = screen->max_row - shift;
  1422.     scrollheight = i - n;
  1423.     refreshheight = n;
  1424.     if((refreshtop = screen->bot_marg - refreshheight + 1 + shift) >
  1425.      (i = screen->max_row - refreshheight + 1))
  1426.         refreshtop = i;
  1427.     if(screen->sb && GetSaveState(screen->sb) && screen->cur_row == 0) {
  1428.         scrolltop = 0;
  1429.         if((scrollheight += shift) > i)
  1430.             scrollheight = i;
  1431.         if((i = -GetScrollBarTop(screen->sb)) < screen->savelines) {
  1432.             if((i += n) > screen->savelines)
  1433.                 i = screen->savelines;
  1434.             SetScrollBarTop(screen->sb, -i);
  1435.             DrawScrollRegion(screen->sb);
  1436.         }
  1437.     } else {
  1438.         scrolltop = screen->cur_row + shift;
  1439.         if((i = screen->bot_marg - bot) > 0) {
  1440.             scrollheight -= i;
  1441.             if((i = screen->cur_row + n - 1 - bot) >= 0) {
  1442.                 refreshheight -= i;
  1443.             }
  1444.         }
  1445.     }
  1446.     if(scrollheight > 0) {
  1447.         if (screen->incopy)
  1448.             CopyWait(screen);
  1449.         screen->incopy = -1;
  1450.  
  1451.         XMoveArea (VWindow(screen), screen->border, (scrolltop + n) *
  1452.          FontHeight(screen) + screen->border + Titlebar(screen),
  1453.          screen->border, scrolltop * FontHeight(screen) + screen->border
  1454.          + Titlebar(screen), Width(screen), scrollheight *
  1455.          FontHeight(screen));
  1456.     }
  1457.     if(refreshheight > 0)
  1458.         XTileSet (VWindow(screen), screen->border, refreshtop *
  1459.          FontHeight(screen) + screen->border + Titlebar(screen),
  1460.          Width(screen), refreshheight * FontHeight(screen),
  1461.          screen->bgndtile);
  1462.     }
  1463.     /* adjust screen->buf */
  1464.     if(screen->sb && GetSaveState(screen->sb) && screen->cur_row == 0)
  1465.         ScrnDeleteLine(screen->allbuf, screen->bot_marg +
  1466.          screen->savelines, 0, n, screen->max_col + 1);
  1467.     else
  1468.         ScrnDeleteLine(screen->buf, screen->bot_marg, screen->cur_row,
  1469.          n, screen->max_col + 1);
  1470. }
  1471.  
  1472. /*
  1473.  * Insert n blanks at the cursor's position, no wraparound
  1474.  */
  1475. InsertChar (screen, n)
  1476. register Screen *screen;
  1477. register int n;
  1478. {
  1479.     register int width = n * FontWidth(screen), cx, cy;
  1480.  
  1481.     if(screen->cursor_state)
  1482.         HideCursor();
  1483.     screen->do_wrap = 0;
  1484.     if(screen->cur_row - screen->topline <= screen->max_row ||
  1485.      screen->instatus) {
  1486.         if(!AddToRefresh(screen)) {
  1487.         if(screen->scroll_amt)
  1488.             FlushScroll(screen);
  1489.     
  1490.         if (screen->incopy)
  1491.             CopyWait (screen);
  1492.         screen->incopy = -1;
  1493.     
  1494.         cx = CursorX (screen, screen->cur_col);
  1495.         cy = CursorY (screen, screen->cur_row);
  1496.         XMoveArea(VWindow(screen), cx, cy, cx + width, cy,
  1497.              Width(screen) - (screen->cur_col + n) * FontWidth(screen),
  1498.              FontHeight(screen));
  1499.         XPixSet(VWindow(screen), cx, cy,
  1500.              width, FontHeight(screen), screen->instatus ?
  1501.              screen->foreground : screen->background);
  1502.     
  1503.         }
  1504.     }
  1505.     /* adjust screen->buf */
  1506.     ScrnInsertChar(screen->buf, screen->cur_row, screen->cur_col, n,
  1507.             screen->max_col + 1);
  1508. }
  1509.  
  1510. /*
  1511.  * Deletes n chars at the cursor's position, no wraparound.
  1512.  */
  1513. DeleteChar (screen, n)
  1514. register Screen *screen;
  1515. register int    n;
  1516. {
  1517.     register int width, cx, cy;
  1518.  
  1519.     if(screen->cursor_state)
  1520.         HideCursor();
  1521.     screen->do_wrap = 0;
  1522.     if (n > (width = screen->max_col + 1 - screen->cur_col))
  1523.           n = width;
  1524.         
  1525.     if(screen->cur_row - screen->topline <= screen->max_row ||
  1526.      screen->instatus) {
  1527.         if(!AddToRefresh(screen)) {
  1528.         if(screen->scroll_amt)
  1529.             FlushScroll(screen);
  1530.     
  1531.         width = n * FontWidth(screen);
  1532.     
  1533.         if (screen->incopy)
  1534.             CopyWait (screen);
  1535.         screen->incopy = -1;
  1536.     
  1537.         cx = CursorX (screen, screen->cur_col);
  1538.         cy = CursorY (screen, screen->cur_row);
  1539.         XMoveArea(VWindow(screen), cx + width, cy, cx, cy,
  1540.              Width(screen) - (screen->cur_col + n) * FontWidth(screen),
  1541.              FontHeight(screen));
  1542.         XPixSet (VWindow(screen),
  1543.              screen->border + Width(screen) - width, cy,
  1544.              width, FontHeight(screen), screen->instatus ?
  1545.              screen->foreground : screen->background);
  1546.     
  1547.         }
  1548.     }
  1549.     /* adjust screen->buf */
  1550.     ScrnDeleteChar (screen->buf, screen->cur_row, screen->cur_col, n,
  1551.             screen->max_col + 1);
  1552.  
  1553. }
  1554.  
  1555. /*
  1556.  * Clear from cursor position to beginning of display, inclusive.
  1557.  */
  1558. ClearAbove (screen)
  1559. register Screen *screen;
  1560. {
  1561.     register top, height;
  1562.  
  1563.     if(screen->cursor_state)
  1564.         HideCursor();
  1565.     if((top = -screen->topline) <= screen->max_row) {
  1566.         if(screen->scroll_amt)
  1567.             FlushScroll(screen);
  1568.         if((height = screen->cur_row + top) > screen->max_row)
  1569.             height = screen->max_row;
  1570.         if((height -= top) > 0)
  1571.             XTileSet(VWindow(screen), screen->border, top *
  1572.              FontHeight(screen) + screen->border + Titlebar(screen),
  1573.              Width(screen), height * FontHeight(screen),
  1574.              screen->bgndtile);
  1575.  
  1576.         if(screen->cur_row - screen->topline <= screen->max_row)
  1577.             ClearLeft(screen);
  1578.     }
  1579.     ClearBufRows(screen, 0, screen->cur_row - 1);
  1580. }
  1581.  
  1582. /*
  1583.  * Clear from cursor position to end of display, inclusive.
  1584.  */
  1585. ClearBelow (screen)
  1586. register Screen *screen;
  1587. {
  1588.     register top;
  1589.  
  1590.     ClearRight(screen);
  1591.     if((top = screen->cur_row - screen->topline) <= screen->max_row) {
  1592.         if(screen->scroll_amt)
  1593.             FlushScroll(screen);
  1594.         if(++top <= screen->max_row)
  1595.             XTileSet(VWindow(screen), screen->border, top *
  1596.              FontHeight(screen) + screen->border + Titlebar(screen),
  1597.              Width(screen), (screen->max_row - top + 1) *
  1598.              FontHeight(screen), screen->bgndtile);
  1599.     }
  1600.     ClearBufRows(screen, screen->cur_row + 1, screen->max_row);
  1601. }
  1602.  
  1603. /* 
  1604.  * Clear last part of cursor's line, inclusive.
  1605.  */
  1606. ClearRight (screen)
  1607. register Screen *screen;
  1608. {
  1609.     if(screen->cursor_state)
  1610.         HideCursor();
  1611.     screen->do_wrap = 0;
  1612.     if(screen->cur_row - screen->topline <= screen->max_row ||
  1613.      screen->instatus) {
  1614.         if(!AddToRefresh(screen)) {
  1615.         if(screen->scroll_amt)
  1616.             FlushScroll(screen);
  1617.         XPixSet(VWindow(screen),
  1618.          CursorX(screen, screen->cur_col),
  1619.          CursorY(screen, screen->cur_row),
  1620.          Width(screen) - screen->cur_col * FontWidth(screen),
  1621.          FontHeight(screen), screen->instatus ? screen->foreground :
  1622.          screen->background);
  1623.         }
  1624.     }
  1625.     bzero(screen->buf [2 * screen->cur_row] + screen->cur_col,
  1626.            (screen->max_col - screen->cur_col + 1));
  1627.     bzero(screen->buf [2 * screen->cur_row + 1] + screen->cur_col,
  1628.            (screen->max_col - screen->cur_col + 1));
  1629. }
  1630.  
  1631. /*
  1632.  * Clear first part of cursor's line, inclusive.
  1633.  */
  1634. ClearLeft (screen)
  1635. register Screen *screen;
  1636. {
  1637.     if(screen->cursor_state)
  1638.         HideCursor();
  1639.     screen->do_wrap = 0;
  1640.     if(screen->cur_row - screen->topline <= screen->max_row ||
  1641.      screen->instatus) {
  1642.         if(!AddToRefresh(screen)) {
  1643.         if(screen->scroll_amt)
  1644.             FlushScroll(screen);
  1645.     
  1646.         XPixSet (VWindow(screen),
  1647.              screen->border, CursorY (screen, screen->cur_row),
  1648.              (screen->cur_col + 1) * FontWidth(screen),
  1649.              FontHeight(screen), screen->instatus ? screen->foreground :
  1650.              screen->background);
  1651.         }
  1652.     }
  1653.     bzero (screen->buf [2 * screen->cur_row], (screen->cur_col + 1));
  1654.     bzero (screen->buf [2 * screen->cur_row + 1], (screen->cur_col + 1));
  1655. }
  1656.  
  1657. /* 
  1658.  * Erase the cursor's line.
  1659.  */
  1660. ClearLine(screen)
  1661. register Screen *screen;
  1662. {
  1663.     if(screen->cursor_state)
  1664.         HideCursor();
  1665.     screen->do_wrap = 0;
  1666.     if(screen->cur_row - screen->topline <= screen->max_row ||
  1667.      screen->instatus) {
  1668.         if(!AddToRefresh(screen)) {
  1669.         if(screen->scroll_amt)
  1670.             FlushScroll(screen);
  1671.         XPixSet (VWindow(screen),
  1672.              screen->border, CursorY (screen, screen->cur_row),
  1673.              Width(screen), FontHeight(screen), screen->instatus ?
  1674.              screen->foreground : screen->background);
  1675.         }
  1676.     }
  1677.     bzero (screen->buf [2 * screen->cur_row], (screen->max_col + 1));
  1678.     bzero (screen->buf [2 * screen->cur_row + 1], (screen->max_col + 1));
  1679. }
  1680.  
  1681. ClearScreen(screen)
  1682. register Screen *screen;
  1683. {
  1684.     register int top;
  1685.  
  1686.     if(screen->cursor_state)
  1687.         HideCursor();
  1688.     screen->do_wrap = 0;
  1689.     if((top = -screen->topline) <= screen->max_row) {
  1690.         if(screen->scroll_amt)
  1691.             FlushScroll(screen);
  1692.         if(top == 0 && !screen->statusline)
  1693.             XClear(VWindow(screen));
  1694.         else
  1695.             XTileSet(VWindow(screen), screen->border, top *
  1696.              FontHeight(screen) + screen->border + Titlebar(screen),
  1697.              Width(screen), (screen->max_row - top + 1) *
  1698.              FontHeight(screen), screen->bgndtile);
  1699.     }
  1700.     ClearBufRows (screen, 0, screen->max_row);
  1701.     screen->pagecnt = 0;
  1702. }
  1703.  
  1704. CopyWait(screen)
  1705. register Screen *screen;
  1706. {
  1707.     XEvent reply;
  1708.     XEvent *rep = &reply;
  1709.  
  1710.     while (1) {
  1711.         XWindowEvent (VWindow(screen), ExposeRegion|ExposeCopy, &reply);
  1712.         switch (reply.type) {
  1713.         case ExposeRegion:
  1714.             if (((XExposeEvent *)rep)->detail == ExposeCopy &&
  1715.                 screen->incopy <= 0) {
  1716.                 screen->incopy = 1;
  1717.                 if (screen->scrolls > 0)
  1718.                     screen->scrolls--;
  1719.             }
  1720.             HandleExposure (screen, &reply);
  1721.             break;
  1722.         case ExposeCopy:
  1723.             if (screen->incopy <= 0 && screen->scrolls > 0)
  1724.                 screen->scrolls--;
  1725.             if (screen->scrolls == 0) {
  1726.                 screen->incopy = 0;
  1727.                 return;
  1728.             }
  1729.             screen->incopy = -1;
  1730.             break;
  1731.         }
  1732.     }
  1733. }
  1734. /*
  1735.  * This routine handles exposure events
  1736.  */
  1737. HandleExposure (screen, reply)
  1738. register Screen *screen;
  1739. register XExposeEvent *reply;
  1740. {
  1741.     register int toprow, leftcol, nrows, ncols;
  1742.     extern Terminal term;    /* kludge */
  1743.     XExposeRegionEvent event;
  1744.  
  1745.     if((toprow = (reply->y - screen->border - Titlebar(screen)) /
  1746.      FontHeight(screen)) < 0)
  1747.         toprow = 0;
  1748.     if((leftcol = (reply->x - screen->border) / FontWidth(screen)) < 0)
  1749.         leftcol = 0;
  1750.     nrows = (reply->y + reply->height - 1 - screen->border
  1751.      - Titlebar(screen)) / FontHeight(screen) - toprow + 1;
  1752.     ncols = (reply->x + reply->width - 1 - screen->border) /
  1753.             FontWidth(screen) - leftcol + 1;
  1754.     toprow -= screen->scrolls;
  1755.     if (toprow < 0) {
  1756.         nrows += toprow;
  1757.         toprow = 0;
  1758.     }
  1759.     if (toprow + nrows - 1 > screen->max_row)
  1760.         nrows = screen->max_row - toprow + 1 + screen->statusline;
  1761.     if (leftcol + ncols - 1 > screen->max_col)
  1762.         ncols = screen->max_col - leftcol + 1;
  1763.  
  1764.     if (nrows > 0 && ncols > 0) {
  1765.         ScrnRefresh (screen, toprow, leftcol, nrows, ncols);
  1766.         if (screen->cur_row >= toprow &&
  1767.             screen->cur_row < toprow + nrows &&
  1768.             screen->cur_col >= leftcol &&
  1769.             screen->cur_col < leftcol + ncols)
  1770.             return (1);
  1771.     }
  1772.     return (0);
  1773. }
  1774.  
  1775. ReverseVideo (term)
  1776.     Terminal *term;
  1777. {
  1778.     register Screen *screen = &term->screen;
  1779.     register Pixmap pix;
  1780.     register int tmp;
  1781.     register Window tek = TWindow(screen);
  1782.     extern Pixmap B_Pixmap;
  1783.     extern Pixmap W_Pixmap;
  1784.  
  1785.     if(screen->color & C_BACKGROUND)
  1786.         XFreePixmap(screen->bgndtile);
  1787.     tmp = screen->background;
  1788.     if(screen->cursorcolor == screen->foreground)
  1789.         screen->cursorcolor = tmp;
  1790.     if(screen->mousecolor == screen->foreground)
  1791.         screen->mousecolor = tmp;
  1792.     screen->background = screen->foreground;
  1793.     screen->foreground = tmp;
  1794.  
  1795.     screen->color = (screen->color & ~C_FBMASK) | switchfb[screen->color
  1796.      & C_FBMASK];
  1797.  
  1798.     if(screen->color & C_BACKGROUND) {
  1799.         if(!(screen->bgndtile = XMakeTile(screen->background)))
  1800.             Error(ERROR_UBACK);
  1801.     } else
  1802.         screen->bgndtile = (screen->background == W_Pixel) ? W_Pixmap
  1803.          : B_Pixmap;
  1804.  
  1805.     XFreeCursor(screen->curs);
  1806.     screen->curs = make_xterm(screen->mousecolor, screen->background,
  1807.      GXcopy);
  1808.     XFreeCursor(screen->arrow);
  1809.     screen->arrow = make_arrow(screen->mousecolor, screen->background,
  1810.      GXcopy);
  1811.  
  1812.     XDefineCursor(VWindow(screen), screen->curs);
  1813.     if(screen->sb)
  1814.         XDefineCursor(screen->sb->bar, screen->sb->cursor =
  1815.          screen->arrow);
  1816.     if(screen->title.tbar)
  1817.         XDefineCursor(screen->title.tbar, screen->arrow);
  1818.     if(tek)
  1819.         XDefineCursor(tek, screen->arrow);
  1820. #ifdef MODEMENU
  1821.     MenuNewCursor(screen->arrow);
  1822. #endif MODEMENU
  1823.  
  1824.     if (screen->background < 2 && screen->foreground < 2) {
  1825.         if (screen->bgndtile == B_Pixmap)
  1826.         screen->bordertile = W_Pixmap;
  1827.         else if (screen->bgndtile == W_Pixmap)
  1828.         screen->bordertile = B_Pixmap;
  1829.         pix = screen->bordertile;
  1830.         if(screen->sb)
  1831.         XChangeBorder (screen->sb->bar, pix);
  1832.         if(screen->title.tbar)
  1833.         XChangeBorder (screen->title.tbar, pix);
  1834.         if(tek && screen->Ttitle.tbar)
  1835.         XChangeBorder (screen->Ttitle.tbar, pix);
  1836.         if(screen->borderwidth > 0) {
  1837.         XChangeBorder (VWindow(screen), pix);
  1838.         XChangeBorder (screen->iconVwin.window, pix);
  1839.         if(tek) {
  1840.             XChangeBorder (tek, pix);
  1841.             XChangeBorder (screen->iconTwin.window, pix);
  1842.         }
  1843.         }
  1844.     }
  1845.  
  1846.     XChangeBackground (VWindow(screen), screen->bgndtile);
  1847.     XChangeBackground (screen->iconVwin.window, screen->bgndtile);
  1848.     if(screen->title.tbar)
  1849.         XChangeBackground (screen->title.tbar, screen->bgndtile);
  1850.     if(tek) {
  1851.         XChangeBackground (screen->iconTwin.window, screen->bgndtile);
  1852.         if(screen->Ttitle.tbar)
  1853.         XChangeBackground (screen->Ttitle.tbar, screen->bgndtile);
  1854.         TekReverseVideo(screen);
  1855.     }
  1856.     XClear (VWindow(screen));
  1857.     XClear (screen->iconVwin.window);
  1858.     ScrnRefresh (screen, 0, 0, screen->max_row + 1 + screen->statusline,
  1859.      screen->max_col + 1);
  1860.     if(screen->Tshow) {
  1861.         XClear (tek);
  1862.         XClear (screen->iconTwin.window);
  1863.         TekExpose((XExposeWindowEvent *)0);
  1864.     }
  1865.     if(Titlebar(screen)) {
  1866.         XClear(screen->title.tbar);
  1867.         VTTitleExpose(NULL);
  1868.         if(screen->Tshow) {
  1869.         XClear(screen->Ttitle.tbar);
  1870.         TekTitleExpose(NULL);
  1871.         }
  1872.     }
  1873. }
  1874. RAZZLE!DAZZLE
  1875. fi    # End util.c
  1876. if test ! -d Xlib
  1877. then
  1878.     mkdir Xlib
  1879. fi
  1880. if test -f Xlib/Makefile
  1881. then
  1882.     echo shar: will not overwrite existing file "'Xlib/Makefile'"
  1883. else
  1884. echo 'x - Xlib/Makefile'
  1885. cat << \RAZZLE!DAZZLE > Xlib/Makefile
  1886. INCLUDES= -I/usr/include/X -I../../Xlib
  1887. C2= /lib/c2
  1888. #
  1889. # The KEYBD define may be include to include the keyboard mods.
  1890. CFLAGS= -O ${INCLUDES} ${NETOPTIONS} -DKEYBD
  1891.  
  1892. .SUFFIXES: .o .h .c
  1893.  
  1894. .c.o:
  1895. #    ${CC} -pg ${CFLAGS} -c -S $*.c
  1896. #    ${C2} $*.s | ../../inline/inline | ${AS} -o $*.o
  1897. #    rm -f $*.s
  1898. #    -ld -X -r $*.o
  1899. #    mv a.out profiled/$*.o
  1900.     ${CC} ${CFLAGS} -c -S $*.c
  1901.     ${C2} $*.s | ../../inline/inline | ${AS} -o $*.o
  1902.     rm -f $*.s
  1903.     -ld -x -r $*.o
  1904.     mv a.out $*.o
  1905.  
  1906. OLIST=    XKeyBind.o
  1907.  
  1908. libX.a: $(OLIST)
  1909.     ar cr libX.a $(OLIST)
  1910.     @ranlib libX.a
  1911. #
  1912. #libX_p.a: $(OLIST)
  1913. #    cd profiled; ar cr ../libX_p.a $(OLIST)
  1914. #    @ranlib libX_p.a
  1915.  
  1916. $(OLIST): ../../Xlib/Xlib.h
  1917.  
  1918. XKeyBind.o: ../../Xlib/Xkeyboard.h ../../Xlib/Xkeymap.h Xdefault.h
  1919.  
  1920. XGetDefault.o: Xdefault.h
  1921. RAZZLE!DAZZLE
  1922. fi    # End Xlib/Makefile
  1923. if test -f Xlib/README
  1924. then
  1925.     echo shar: will not overwrite existing file "'Xlib/README'"
  1926. else
  1927. echo 'x - Xlib/README'
  1928. cat << \RAZZLE!DAZZLE > Xlib/README
  1929. This directory contains a changes to the Xlib routines XKeyBind.c:
  1930.  
  1931. XKeyBind.c:    This will allow (in the future) to define keymaps with
  1932.         the environment variable KEYBD.  This is needed, for example,
  1933.         when I log into a Sun from some other workstation.  Then, on
  1934.         the Sun, I wish to pop a window back on my workstation.  Since
  1935.         the default keymap would be for the Sun, if I were on some
  1936.         other workstation, my keyboard would be messed up.  I could
  1937.         keep a .Xkeymap file on the Sun, but if I use different
  1938.         workstations to log in, sometimes it might work and other times
  1939.         it wouldn't.  If I were originally on a MicroVax and set
  1940.         my KEYBD environment variable (from the .login file) to
  1941.         mvaxII, for instance, then I would get the right keymap.  From
  1942.         another Sun, I might set KEYBD to sun3.  The names of these
  1943.         keymap files have not yet been established yet.
  1944. RAZZLE!DAZZLE
  1945. fi    # End Xlib/README
  1946. if test -f Xlib/XKeyBind.c
  1947. then
  1948.     echo shar: will not overwrite existing file "'Xlib/XKeyBind.c'"
  1949. else
  1950. echo 'x - Xlib/XKeyBind.c'
  1951. cat << \RAZZLE!DAZZLE > Xlib/XKeyBind.c
  1952. #include <X/mit-copyright.h>
  1953.  
  1954. /* $Header: XKeyBind.c,v 10.12 86/07/21 15:27:14 wesommer Rel $ */
  1955. /* Copyright 1985, Massachusetts Institute of Technology */
  1956.  
  1957. #include "XlibInternal.h"
  1958. #include <sys/file.h>
  1959. #include <sys/stat.h>
  1960. #include "Xkeymap.h"
  1961. #include "Xkeyboard.h"
  1962. #include <stdio.h>
  1963. #include <strings.h>
  1964. #ifdef KEYBD
  1965. #include "Xdefault.h"
  1966. #endif KEYBD
  1967.  
  1968. #define EMPTY_ENTRY LeftMask 
  1969.    /* if the "metabits" field of a runtime table entry contains this,
  1970.     it's an empty entry */
  1971.  
  1972. static KeyMapElt *keymap = NULL;
  1973. static Bool inited = FALSE;
  1974.  
  1975. static ExtensionHeader *ext_begin, *ext_end;
  1976.  
  1977. /* Runtime table: contains multiple-byte character bindings defined
  1978.   at runtime with XRebindCode */
  1979.  
  1980. typedef struct {
  1981.     unsigned char keycode;
  1982.     unsigned short metabits;
  1983.     short length;
  1984.     char *value;
  1985.     } RuntimeTableEntry;
  1986.  
  1987. static RuntimeTableEntry
  1988.    *rt_begin,  /* first entry of runtime table */
  1989.    *rt_end,    /* this and all succeeding entries are empty */
  1990.    *rt_buf_end;/* points beyond end of allocated storage for table */
  1991.  
  1992. #ifdef KEYBD
  1993. char *keyboardtype = NULL;
  1994. #endif KEYBD
  1995.  
  1996. #define RT_INITIAL_SIZE 100  /* initial size of runtime table */
  1997. #define RT_INCREMENT 40  /* size to grow by if expanded */
  1998.  
  1999. XUseKeymap(filename) 
  2000.     char *filename;
  2001. {
  2002.     int file = -1;
  2003.     int filesize;
  2004.     unsigned char magic;
  2005.     struct stat filestat;
  2006.     file = open (filename, O_RDONLY, 0);
  2007.     if (file < 0) {
  2008.         return(0);        /* no keymap file found */
  2009.     }
  2010.     fstat (file, &filestat);
  2011.     filesize = filestat.st_size - 1; /* first byte is magic number */
  2012.     if (filesize < 256*sizeof(KeyMapElt)) {
  2013.     fprintf (stderr, "Keymap file %s is too small\n", filename);
  2014.     close (file);
  2015.     return(0);
  2016.     }
  2017.     read (file, &magic, 1);
  2018.     if (magic != X_KEYMAP_MAGIC) {
  2019.     fprintf (stderr, 
  2020.       "Keymap file %s doesn't begin with the proper magic number\n",
  2021.       filename);
  2022.         close (file);
  2023.           return(0);
  2024.     }
  2025.     keymap = (KeyMapElt *) malloc (filesize);
  2026.     if (!keymap) {
  2027.     close (file);
  2028.           return(0);  /* couldn't malloc; just act like there isn't a keymap */
  2029.     }
  2030.     read (file, (char *) keymap, filesize);
  2031.     ext_begin = (ExtensionHeader *) (keymap + 256);
  2032.     ext_end = (ExtensionHeader *) (((char *) keymap) + filesize);
  2033.     rt_begin = (RuntimeTableEntry *) malloc (RT_INITIAL_SIZE*sizeof(RuntimeTableEntry));
  2034.     if (!rt_begin)
  2035.          _XIOError (_XlibCurrentDisplay);
  2036.     rt_end = rt_begin;
  2037.     rt_buf_end = rt_begin + RT_INITIAL_SIZE;
  2038.     close (file);
  2039.     inited = TRUE;
  2040.     return(1);
  2041. }
  2042.  
  2043. static Initialize() {
  2044.     int file = -1;
  2045.     int filesize;
  2046.     unsigned char magic;
  2047.     struct stat filestat;
  2048.     char *getenv();
  2049.     char *filename = NULL;
  2050. #ifdef KEYBD
  2051.     char *home;
  2052.     char *kdefault = "default";
  2053.     char *keybddir = KEYBDDIR;
  2054. #else KEYBD
  2055.     char *home = getenv ("HOME");
  2056. #endif KEYBD
  2057.  
  2058.     inited = TRUE;
  2059. #ifdef KEYBD
  2060.     if(keyboardtype && *keyboardtype) {    /* Use keyboard type keymap */
  2061.     filename = malloc(strlen(keybddir) + strlen(keyboardtype) + 1);
  2062.     strcpy(filename, keybddir);
  2063.     strcat(filename, keyboardtype);
  2064.     if((file = open (filename, O_RDONLY, 0)) < 0) {
  2065.         free (filename);
  2066.         filename = NULL;
  2067.     }
  2068.     }
  2069.     if(file < 0 && (home = getenv ("HOME")))
  2070. #else KEYBD
  2071.     if (home)
  2072. #endif KEYBD
  2073.      {
  2074.     int homelen = strlen (home);
  2075.     char *keymapstr = "/.Xkeymap";
  2076.     int keymapstrlen = strlen (keymapstr);
  2077.     filename = malloc (homelen + keymapstrlen + 1);
  2078.     strncpy (filename, home, homelen+1);
  2079.     strncat (filename, keymapstr, keymapstrlen);
  2080.     file = open (filename, O_RDONLY, 0);
  2081.     }
  2082. #ifdef KEYBD
  2083.     if (file < 0) {    /* Try system default keymap */
  2084.     if(filename)
  2085.         free(filename);
  2086.     filename = malloc(strlen(keybddir) + strlen(kdefault) + 1);
  2087.     strcpy(filename, keybddir);
  2088.     strcat(filename, kdefault);
  2089.     file = open (filename, O_RDONLY, 0);
  2090.     }
  2091. #endif KEYBD
  2092.     if (file < 0) {
  2093.     if(filename)
  2094.         free(filename);
  2095.     return; /* no keymap file found */
  2096.     }
  2097.     fstat (file, &filestat);
  2098.     filesize = filestat.st_size - 1; /* first byte is magic number */
  2099.     if (filesize < 256*sizeof(KeyMapElt)) {
  2100.     fprintf (stderr, "Keymap file %s is too small\n", filename);
  2101.     close (file);
  2102.     free (filename);
  2103.     return;
  2104.     }
  2105.     read (file, &magic, 1);
  2106.     if (magic != X_KEYMAP_MAGIC) {
  2107.     fprintf (stderr, 
  2108.       "Keymap file %s doesn't begin with the proper magic number\n",
  2109.       filename);
  2110.         close (file);
  2111.     free (filename);
  2112.           return;
  2113.     }
  2114.     keymap = (KeyMapElt *) malloc (filesize);
  2115.     if (!keymap) {
  2116.     close (file);
  2117.     free (filename);
  2118.           return;  /* couldn't malloc; just act like there isn't a keymap */
  2119.     }
  2120.     read (file, (char *) keymap, filesize);
  2121.     ext_begin = (ExtensionHeader *) (keymap + 256);
  2122.     ext_end = (ExtensionHeader *) (((char *) keymap) + filesize);
  2123.     rt_begin = (RuntimeTableEntry *) malloc (RT_INITIAL_SIZE*sizeof(RuntimeTableEntry));
  2124.     if (!rt_begin)
  2125.          _XIOError (_XlibCurrentDisplay);
  2126.     rt_end = rt_begin;
  2127.     rt_buf_end = rt_begin + RT_INITIAL_SIZE;
  2128.     free (filename);
  2129.     close (file);
  2130.     }
  2131.  
  2132. /* this routine is used when initialization failed to find a
  2133.    valid keymap file */
  2134. static char *BackstopLookupMapping (event, nbytes)
  2135.     XKeyPressedEvent *event;
  2136.     int *nbytes;
  2137.     {
  2138.     int detail = event->detail;
  2139.     register int keycode = detail & ValueMask;
  2140.     extern KeyMapEntry StdMap[];
  2141.     static char c;
  2142.     short s;  /* needed to distinguish a real character (e.g. \0377) from -1 */
  2143.     s = StdMap [keycode] [KeyState(detail)];
  2144.     c = s;
  2145.     if ((detail & ShiftLockMask) && (c >= 'a') && (c <= 'z'))
  2146.         c += ('A' - 'a');
  2147.     if (IsTypewriterKey(keycode)
  2148.       || keycode == KC_ESC || keycode == KC_BS || keycode == KC_LF)
  2149.     *nbytes = (s == -1 ? 0 : 1);
  2150.     else
  2151.         *nbytes = 0;
  2152.     return (&c);
  2153.     }
  2154.  
  2155. char *XLookupMapping (event, nbytes)
  2156.     XKeyPressedEvent *event;
  2157.     int *nbytes;
  2158.     {
  2159.     int detail = event->detail;
  2160.     unsigned int metabits = FullKeyState (detail);
  2161.     unsigned int key = detail & ValueMask;
  2162.     register unsigned char *the_char;
  2163.  
  2164.     if (!inited)
  2165.           Initialize();
  2166.     if (!keymap)
  2167.         return (BackstopLookupMapping (event, nbytes));
  2168.  
  2169.     the_char = &keymap [key] [metabits];
  2170.  
  2171.     switch (*the_char) {
  2172.  
  2173.           case UNBOUND: {
  2174.         *nbytes = 0;
  2175.         return (NULL);
  2176.         }
  2177.  
  2178.           case EXTENSION_BOUND: {
  2179.         register ExtensionHeader *this;
  2180.         for (this = ext_begin; this < ext_end; NextExtension(this))
  2181.             if ((key == this->keycode)
  2182.             && ((metabits == this->metabits) || (this->metabits == DontCareMetaBits))) {
  2183.                 *nbytes = this->length;
  2184.                 return ((char *)this + ExtensionHeaderSize);
  2185.                 }
  2186.         /* if we get here, no match was found in the table extension */
  2187.         *nbytes = 0;
  2188.         return (NULL);
  2189.         }
  2190.  
  2191.         case RUNTIME_TABLE_BOUND: {
  2192.         register RuntimeTableEntry *entry;
  2193.         for (entry = rt_begin; entry < rt_end; entry++)
  2194.             if ((key == entry->keycode)
  2195.             && ((metabits == entry->metabits) || (entry->metabits == DontCareMetaBits))) {
  2196.             *nbytes = entry->length;
  2197.             return (entry->value);
  2198.             }
  2199.  
  2200.         /* if we get here, no match was found in the runtime table */
  2201.         *nbytes = 0;
  2202.         return (NULL);
  2203.         }
  2204.  
  2205.     default: {
  2206.         *nbytes = 1;
  2207.         return ((char *)the_char);
  2208.         }
  2209.           }
  2210.  
  2211.     }
  2212.  
  2213.  
  2214. XRebindCode (keycode, metabits, str, nbytes)
  2215.     unsigned int keycode, metabits;
  2216.     char *str;
  2217.     int nbytes;
  2218.     {
  2219.     unsigned char *table_char;
  2220.     metabits = FullKeyState (metabits);  /* shift meta bits to rightmost four bits */
  2221.     if (!inited)
  2222.         Initialize();
  2223.     if (!keymap)
  2224.         return;  /* no keymap file; what else can I do? */
  2225.     table_char = &keymap [keycode] [metabits];
  2226.     if (nbytes == 0) {
  2227.     if (*table_char == RUNTIME_TABLE_BOUND)
  2228.         Unbind (keycode, metabits);
  2229.     *table_char = UNBOUND;
  2230.     return;
  2231.     }
  2232.     if ((nbytes == 1) && SingleCharBound (*str)) {
  2233.         if (*table_char == RUNTIME_TABLE_BOUND)
  2234.         Unbind (keycode, metabits);
  2235.     *table_char = *str;
  2236.     return;
  2237.     }
  2238.     
  2239.     /* the new binding is either multi-character, or one of the
  2240.        three reserved special characters */
  2241.  
  2242.     if (*table_char == RUNTIME_TABLE_BOUND) {
  2243.     /* entry is already in table; just change its binding */
  2244.     register RuntimeTableEntry *entry;
  2245.     for (entry = rt_begin; entry < rt_end; entry++)
  2246.         if (keycode == entry->keycode && metabits == entry->metabits) {
  2247.         entry->value = str;
  2248.         entry->length = nbytes;
  2249.         return;
  2250.         }
  2251.     /* if we get here, entry wasn't found in table; shouldn't
  2252.      * ever happen!  Not much to do but fall through to 
  2253.      * the following code.  */
  2254.         }
  2255.  
  2256.     /* new binding must go in a new entry in the table */
  2257.     *table_char = RUNTIME_TABLE_BOUND;
  2258.     if (rt_end < rt_buf_end) {
  2259.     rt_end->keycode = keycode;
  2260.     rt_end->metabits = metabits;
  2261.     rt_end->value = str;
  2262.     rt_end++->length = nbytes;
  2263.     return;
  2264.     }
  2265.  
  2266.     /* no room at end of table; look for holes in middle */
  2267.     {
  2268.     register RuntimeTableEntry *entry;
  2269.     for (entry = rt_begin; entry < rt_end; entry++)
  2270.         if (entry->metabits == EMPTY_ENTRY) {
  2271.         entry->keycode = keycode;
  2272.         entry->metabits = metabits;
  2273.         entry->value = str;
  2274.         entry->length = nbytes;
  2275.         return;
  2276.         }
  2277.     }
  2278.  
  2279.     /* no room in table at all.  Must expand it. */
  2280.     {
  2281.     int rt_length = rt_end - rt_begin;
  2282.     rt_begin = (RuntimeTableEntry *) realloc ((char *)rt_begin, (rt_length+RT_INCREMENT)*sizeof (RuntimeTableEntry));
  2283.     rt_end = rt_begin + rt_length;
  2284.     rt_buf_end = rt_end + RT_INCREMENT;
  2285.     rt_end->keycode = keycode;
  2286.     rt_end->metabits = metabits;
  2287.     rt_end->value = str;
  2288.     rt_end++->length = nbytes;
  2289.     }
  2290.     }
  2291.     
  2292.  
  2293. static Unbind (keycode, metabits)
  2294.     unsigned int keycode, metabits;
  2295.     {
  2296.     register RuntimeTableEntry *entry;
  2297.     for (entry = rt_begin; entry < rt_end; entry++)
  2298.         if (keycode == entry->keycode && metabits == entry->metabits) {
  2299.         entry->metabits = EMPTY_ENTRY;
  2300.         return;
  2301.         }
  2302.     }
  2303. RAZZLE!DAZZLE
  2304. fi    # End Xlib/XKeyBind.c
  2305. echo '***** End of' xterm 6.6B - Part 7 of 7 '*****'
  2306. exit
  2307.